home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / vidhrdw / mnight.c < prev    next >
C/C++ Source or Header  |  2000-05-04  |  6KB  |  242 lines
  1. #include "driver.h"
  2. #include "vidhrdw/generic.h"
  3.  
  4. #define COLORTABLE_START(gfxn,color)    Machine->drv->gfxdecodeinfo[gfxn].color_codes_start + \
  5.                     color * Machine->gfx[gfxn]->color_granularity
  6. #define GFX_COLOR_CODES(gfxn)         Machine->gfx[gfxn]->total_colors
  7. #define GFX_ELEM_COLORS(gfxn)         Machine->gfx[gfxn]->color_granularity
  8.  
  9. unsigned char   *mnight_scrolly_ram;
  10. unsigned char   *mnight_scrollx_ram;
  11. unsigned char   *mnight_bgenable_ram;
  12. unsigned char   *mnight_spoverdraw_ram;
  13. unsigned char   *mnight_spriteram;
  14. size_t mnight_spriteram_size;
  15. unsigned char   *mnight_background_videoram;
  16. size_t mnight_backgroundram_size;
  17. unsigned char   *mnight_foreground_videoram;
  18. size_t mnight_foregroundram_size;
  19.  
  20. static struct osd_bitmap *bitmap_bg;
  21. static struct osd_bitmap *bitmap_sp;
  22.  
  23. static unsigned char     *bg_dirtybuffer;
  24. static int       bg_enable = 1;
  25. static int       sp_overdraw = 0;
  26.  
  27. int mnight_vh_start(void)
  28. {
  29.     int i;
  30.  
  31.     if ((bg_dirtybuffer = malloc(1024)) == 0)
  32.     {
  33.         return 1;
  34.     }
  35.     if ((bitmap_bg = osd_new_bitmap (Machine->drv->screen_width*2,Machine->drv->screen_height*2,Machine->scrbitmap->depth)) == 0)
  36.     {
  37.         free (bg_dirtybuffer);
  38.         return 1;
  39.     }
  40.     if ((bitmap_sp = osd_new_bitmap (Machine->drv->screen_width,Machine->drv->screen_height,Machine->scrbitmap->depth)) == 0)
  41.     {
  42.         free (bg_dirtybuffer);
  43.         free (bitmap_bg);
  44.         return 1;
  45.     }
  46.     memset(bg_dirtybuffer,1,1024);
  47.  
  48.     /* chars, background tiles, sprites */
  49.     memset(palette_used_colors,PALETTE_COLOR_USED,Machine->drv->total_colors * sizeof(unsigned char));
  50.  
  51.     for (i = 0;i < GFX_COLOR_CODES(1);i++)
  52.     {
  53.         palette_used_colors[COLORTABLE_START(1,i)+15] = PALETTE_COLOR_TRANSPARENT;
  54.         palette_used_colors[COLORTABLE_START(2,i)+15] = PALETTE_COLOR_TRANSPARENT;
  55.     }
  56.     return 0;
  57. }
  58.  
  59. void mnight_vh_stop(void)
  60. {
  61.     osd_free_bitmap(bitmap_bg);
  62.     osd_free_bitmap(bitmap_sp);
  63.     free(bg_dirtybuffer);
  64. }
  65.  
  66.  
  67. WRITE_HANDLER( mnight_bgvideoram_w )
  68. {
  69.     if (mnight_background_videoram[offset] != data)
  70.     {
  71.         bg_dirtybuffer[offset >> 1] = 1;
  72.         mnight_background_videoram[offset] = data;
  73.     }
  74. }
  75.  
  76. WRITE_HANDLER( mnight_fgvideoram_w )
  77. {
  78.     if (mnight_foreground_videoram[offset] != data)
  79.         mnight_foreground_videoram[offset] = data;
  80. }
  81.  
  82. WRITE_HANDLER( mnight_background_enable_w )
  83. {
  84.     if (bg_enable!=data)
  85.     {
  86.         mnight_bgenable_ram[offset] = data;
  87.         bg_enable = data;
  88.         if (bg_enable)
  89.             memset(bg_dirtybuffer, 1, mnight_backgroundram_size / 2);
  90.         else
  91.             fillbitmap(bitmap_bg, palette_transparent_pen,0);
  92.     }
  93. }
  94.  
  95. WRITE_HANDLER( mnight_sprite_overdraw_w )
  96. {
  97.     if (sp_overdraw != (data&1))
  98.     {
  99.         mnight_spoverdraw_ram[offset] = data;
  100.         fillbitmap(bitmap_sp,15,&Machine->drv->visible_area);
  101.         sp_overdraw = data & 1;
  102.     }
  103. }
  104.  
  105. void mnight_draw_foreground(struct osd_bitmap *bitmap)
  106. {
  107.     int offs;
  108.  
  109.     /* Draw the foreground text */
  110.  
  111.     for (offs = 0 ;offs < mnight_foregroundram_size / 2; offs++)
  112.     {
  113.         int sx,sy,tile,palette,flipx,flipy,lo,hi;
  114.  
  115.         if (mnight_foreground_videoram[offs*2] | mnight_foreground_videoram[offs*2+1])
  116.         {
  117.             sx = (offs % 32) << 3;
  118.             sy = (offs >> 5) << 3;
  119.  
  120.             lo = mnight_foreground_videoram[offs*2];
  121.             hi = mnight_foreground_videoram[offs*2+1];
  122.             tile = ((hi & 0xc0) << 2) | lo;
  123.             flipx = hi & 0x10;
  124.             flipy = hi & 0x20;
  125.             palette = hi & 0x0f;
  126.  
  127.             drawgfx(bitmap,Machine->gfx[3],
  128.                     tile,
  129.                     palette,
  130.                     flipx,flipy,
  131.                     sx,sy,
  132.                     &Machine->drv->visible_area,TRANSPARENCY_PEN, 15);
  133.         }
  134.  
  135.     }
  136. }
  137.  
  138.  
  139. void mnight_draw_background(struct osd_bitmap *bitmap)
  140. {
  141.     int offs;
  142.  
  143.     /* for every character in the Video RAM, check if it has been modified */
  144.     /* since last time and update it accordingly. */
  145.  
  146.     for (offs = 0 ;offs < mnight_backgroundram_size / 2; offs++)
  147.     {
  148.         int sx,sy,tile,palette,flipy,lo,hi;
  149.  
  150.         if (bg_dirtybuffer[offs])
  151.         {
  152.             sx = (offs % 32) << 4;
  153.             sy = (offs >> 5) << 4;
  154.  
  155.             bg_dirtybuffer[offs] = 0;
  156.  
  157.             lo = mnight_background_videoram[offs*2];
  158.             hi = mnight_background_videoram[offs*2+1];
  159.             tile = ((hi & 0x10) << 6) | ((hi & 0xc0) << 2) | lo;
  160.             flipy = hi & 0x20;
  161.             palette = hi & 0x0f;
  162.             drawgfx(bitmap,Machine->gfx[0],
  163.                     tile,
  164.                     palette,
  165.                     0,flipy,
  166.                     sx,sy,
  167.                     0,TRANSPARENCY_NONE,0);
  168.         }
  169.  
  170.     }
  171. }
  172.  
  173. void mnight_draw_sprites(struct osd_bitmap *bitmap)
  174. {
  175.     int offs;
  176.  
  177.     /* Draw the sprites */
  178.  
  179.     for (offs = 11 ;offs < mnight_spriteram_size; offs+=16)
  180.     {
  181.         int sx,sy,tile,palette,flipx,flipy,big;
  182.  
  183.         if (mnight_spriteram[offs+2] & 2)
  184.         {
  185.             sx = mnight_spriteram[offs+1];
  186.             sy = mnight_spriteram[offs];
  187.             if (mnight_spriteram[offs+2] & 1) sx-=256;
  188.             tile = mnight_spriteram[offs+3]+((mnight_spriteram[offs+2] & 0xc0)<<2) + ((mnight_spriteram[offs+2] & 0x08)<<7);
  189.             big  = mnight_spriteram[offs+2] & 4;
  190.             if (big) tile /= 4;
  191.             flipx = mnight_spriteram[offs+2] & 0x10;
  192.             flipy = mnight_spriteram[offs+2] & 0x20;
  193.             palette = mnight_spriteram[offs+4] & 0x0f;
  194.             drawgfx(bitmap,Machine->gfx[(big)?2:1],
  195.                     tile,
  196.                     palette,
  197.                     flipx,flipy,
  198.                     sx,sy,
  199.                     &Machine->drv->visible_area,
  200.                     TRANSPARENCY_PEN, 15);
  201.         }
  202.     }
  203. }
  204.  
  205.  
  206. /***************************************************************************
  207.  
  208.   Draw the game screen in the given osd_bitmap.
  209.   Do NOT call osd_update_display() from this function, it will be called by
  210.   the main emulation engine.
  211.  
  212. ***************************************************************************/
  213. void mnight_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
  214. {
  215.     int scrollx,scrolly;
  216.  
  217.     /* TODO: handle palette properly, it overflows */
  218.     if (palette_recalc ())
  219.         memset(bg_dirtybuffer, 1, mnight_backgroundram_size / 2);
  220.  
  221.     if (bg_enable)
  222.         mnight_draw_background(bitmap_bg);
  223.  
  224.     scrollx = -((mnight_scrollx_ram[0]+mnight_scrollx_ram[1]*256) & 0x1FF);
  225.     scrolly = -((mnight_scrolly_ram[0]+mnight_scrolly_ram[1]*256) & 0x1FF);
  226.  
  227.     if (sp_overdraw)    /* overdraw sprite mode */
  228.     {
  229.         copyscrollbitmap(bitmap,bitmap_bg,1,&scrollx,1,&scrolly,&Machine->drv->visible_area,TRANSPARENCY_NONE,0);
  230.         mnight_draw_sprites(bitmap_sp);
  231.         mnight_draw_foreground(bitmap_sp);
  232.         copybitmap(bitmap,bitmap_sp,0,0,0,0,&Machine->drv->visible_area,TRANSPARENCY_PEN, 15);
  233.     }
  234.     else            /* normal sprite mode */
  235.     {
  236.         copyscrollbitmap(bitmap,bitmap_bg,1,&scrollx,1,&scrolly,&Machine->drv->visible_area,TRANSPARENCY_NONE,0);
  237.         mnight_draw_sprites(bitmap);
  238.         mnight_draw_foreground(bitmap);
  239.     }
  240.  
  241. }
  242.